package itheima08;
/*
    问题1:
	1.sleep方法可以在同步中使用
	2.sleep方法可以在非同步中使用
	3.sleep方法与锁对象无关(不会释放锁)

    问题2:
        1.Object类定义wait和notify方法
        2.任意对象都可以调用wait和notify方法
        3.锁对象可以是任意对象
        4.但是锁对象必须使用在同步中,所以wait和notify方法,必须在同步中使用

    java.lang.Object类,方法
         public void wait(): 释放锁对象,进入无限等待
            在其他线程调用此对象的 notify() 方法前，导致当前线程等待
         public void notify(): 唤醒在此对象监视器(锁对象)上等待的单个线程。
 */
/*public class Demo02WaitNotify {
    public static void main(String[] args) {
        //创建锁对象
        Object obj = new Object();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("只听了3分钟,这哥们睡着了....");
                    try {
                        obj.wait();//无限等待,释放锁对象,必须由其它线程,通过obj锁,调用notify方法,才能唤醒它
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("听响哥的课,还敢睡觉,拍你一砖头,继续护着头听课.....");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        Thread.sleep(30000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("你小子,不想混了,这个课多重要,不能睡觉,给你一砖头...");
                    obj.notify();
                }
            }
        }).start();
    }
}*/

public class Demo02WaitNotify{
    public static void main(String[] args) {
        //创建锁对象
        Object obj=new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj){
                    try {
                      Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("1");
                    try{
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("2");
                }
            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(obj){
                    try{
                        Thread.sleep(30000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("3");
                    obj.notify();//将锁对象释放交由前面等待的对应线程继续执行
                }


        }
        }).start();
    }
}